home *** CD-ROM | disk | FTP | other *** search
/ c't freeware shareware 2001 January / CT_SW0101.ISO / pc / software / kommunik / multimed / snakppc.sit / Snak 4.6.3 / Scripts / pp-dcc.irc < prev    next >
Text File  |  2001-03-20  |  28KB  |  919 lines
  1. # ########################################################################## #
  2. #                      PurePak - The sequel to TextBox                       #
  3. #                          A -+ TEXT +- production                           #
  4. # ########################################################################## #
  5. # Author: Crypt Keeper [ckeeper@axiom.access.one.net] (CKeeper on IRC)
  6. # Version 2.07
  7. #
  8. # This script requires at least ircII2.2.9 (Unix) or a fully ircII compatible
  9. # client.  It has only been tested under Unix with ircII2.2.9 and ircII2.8.2.
  10. #
  11. # If you edit this file, you must edit it with a Unix text editor or use
  12. # utilities like dos2unix/unix2dos to convert it to DOS to edit and then
  13. # back to Unix.  If it is edited in a DOS text editor it will be corrupted.
  14. #
  15. # PurePak version 2.07 IRC script
  16. # Copyright (C) 1995
  17. #
  18. # This program is free software; you can redistribute it and/or modify
  19. # it under the terms of the GNU General Public License as published by
  20. # the Free Software Foundation; either version 1, or (at your option)
  21. # any later version.
  22. #
  23. # This program is distributed in the hope that it will be useful,
  24. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  25. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26. # GNU General Public License for more details.
  27. #
  28. # You should have received a copy of the GNU General Public License
  29. # along with this program; if not, write to the Free Software
  30. # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31. # ########################################################################## #
  32.  
  33. EVAL ^if (!(PPVERS)) {/echo *** This is not a stand-alone script, it must be loaded after purepak.irc;//exit}
  34.  
  35. # DCC fileserver/manager script
  36. @ PP.DCC = 1
  37.  
  38. # ----------------------------------------------------------------------------
  39. # DCC alias
  40. # ----------------------------------------------------------------------------
  41.  
  42. alias xdcc {/dcc $*}
  43. alias dcc {
  44.     if ([$0])
  45.     {
  46.         if (match($0 SEND GET RAW TALK CHAT OFFER DOFFER LIST PLIST NOTICE DLDIR FRIENDS AUTOGET LOAD SAVE CLOSE LIMIT RENAME TMSG NOTE SERVER TIMEOUT QUEUEING PUBLIST AUTOCHAT))
  47.         {
  48.             if (match($0 RAW TALK RENAME TMSG SEND CHAT)) {//dcc $*}
  49.             if (match($0 CLOSE OFFER DOFFER LIST PLIST NOTICE DLDIR AUTOGET FRIENDS LOAD SAVE GET LIMIT NOTE SERVER TIMEOUT QUEUEING PUBLIST AUTOCHAT)) {/dcc.ucmd.$0 $1-}
  50.         } {/echo *** Unrecognized DCC command, type /pphelp dcc}
  51.     }
  52.     {
  53.         if (!PP.EPIC)
  54.         {
  55.             dcc.updatestatus
  56.             @ GDCCS = 0
  57.             if (DCC.GETS)
  58.             {
  59.                 @ GDCCS = 1
  60.                 echo *** Incoming files: From      Status      Read       Filename
  61.                 foreach DCC.GETS AA {
  62.                     EVAL ^foreach DCC.GETS.$AA XY {
  63.                         @ NK = decode($AA)
  64.                         if (word(0 $DCC.GETS[$AA][$XY]) == [W]) {@ ST = [Waiting]} {@ ST = [In Progress]}
  65.                         @ BT = word(2 $DCC.GETS[$AA][$XY])
  66.                         echo ***                 $[9]NK $[11]ST $[10]BT $right(24 $decode($XY))
  67.                     }
  68.                 }
  69.             }
  70.             if (DCC.SENDS)
  71.             {
  72.                 @ GDCCS = 1
  73.                 echo *** Outgoing files: To        Status      Written    Filename
  74.                 foreach DCC.SENDS AA {
  75.                     EVAL ^foreach DCC.SENDS.$AA XY {
  76.                         @ NK = decode($AA)
  77.                         if (word(0 $DCC.SENDS[$AA][$XY]) == [W]) {@ ST = [Waiting]} {@ ST = [In Progress]}
  78.                         @ BT = word(1 $DCC.SENDS[$AA][$XY])
  79.                         echo ***                 $[9]NK $[11]ST $[10]BT $right(24 $decode($XY))
  80.                     }
  81.                 }
  82.             }
  83.             if (DCC.CHATS)
  84.             {
  85.                 foreach DCC.CHATS AA {
  86.                     if (word(0 $DCC.CHATS[$AA]) == [W]) {/echo *** DCC CHAT request to $decode($AA) not established (waiting)}
  87.                     if (word(0 $DCC.CHATS[$AA]) == [O]) {/echo *** DCC CHAT offered from $decode($AA)}
  88.                     if (word(0 $DCC.CHATS[$AA]) == [A]) {/echo *** DCC CHAT active to $decode($AA)}
  89.                 }
  90.                 @ GDCCS = 1
  91.             }
  92.             if (GDCCS) {^assign -XY}
  93.             {/echo *** No active DCC CHAT, SEND, or GET connections}
  94.             ^assign -GDCCS
  95.         } {//dcc}
  96.     }
  97. }
  98.  
  99. EVAL ^if (!PP.SET.DCCDLDIR) {@ PP.SET.DCCDLDIR = [.]}
  100. EVAL ^if (!PP.SET.DCCAUTOGET) {@ PP.SET.DCCAUTOGET = [OFF]}
  101. EVAL ^if (!PP.SET.DCCFLAUTOGET) {@ PP.SET.DCCFLAUTOGET = [ON]}
  102. EVAL ^if (!PP.SET.DCCLIMIT) {@ PP.SET.DCCLIMIT = [-1]}
  103. EVAL ^if (!PP.SET.DCCSERVER) {@ PP.SET.DCCSERVER = [ON]}
  104. EVAL ^if (!PP.SET.DCCTIMEOUT) {@ PP.SET.DCCTIMEOUT = 90}
  105. EVAL ^if (!PP.SET.DCCPUBLIST) {@ PP.SET.DCCPUBLIST = [ON]}
  106. EVAL ^if (!PP.SET.DCCQUEUEING) {@ PP.SET.DCCQUEUEING = [ON]}
  107. EVAL ^if (!PP.SET.DCCAUTOCHAT) {@ PP.SET.DCCAUTOCHAT = [OFF]}
  108.  
  109. # ----------------------------------------------------------------------------
  110. # /dcc functions
  111. # ----------------------------------------------------------------------------
  112.  
  113. # /dcc autochat
  114. alias dcc.ucmd.autochat {
  115.     if (match($0 ON OFF)) {@ PP.SET.DCCAUTOCHAT = toupper($0)}
  116.     echo *** Auto accept DCC CHAT requests is now ${PP.SET.DCCAUTOCHAT}
  117. }
  118. # /dcc queueing
  119. alias dcc.ucmd.queueing {
  120.     if (match($0 ON OFF)) {@ PP.SET.DCCQUEUEING = toupper($0)}
  121.     echo *** Queueing of send requests if all slots are full is now ${PP.SET.DCCQUEUEING}
  122. }
  123. # /dcc server
  124. alias dcc.ucmd.server {
  125.     if (match($0 ON OFF)) {@ PP.SET.DCCSERVER = toupper($0)}
  126.     echo *** DCC server is now ${PP.SET.DCCSERVER}
  127. }
  128. # /dcc publist
  129. alias dcc.ucmd.publist {
  130.     if (match($0 ON OFF)) {@ PP.SET.DCCPUBLIST = toupper($0)}
  131.     echo *** Allow public CTCP XDCC LISTs is now ${PP.SET.DCCPUBLIST}
  132. }
  133. # /dcc note
  134. alias dcc.ucmd.note {
  135.     if ([$0]) {^if ([$0] != [-]) {@ DCC.NOTE = [$*]} {^assign -DCC.NOTE}}
  136.     if (DCC.NOTE) {/echo *** DCC offer list note: $DCC.NOTE} {/echo *** No DCC offer list note set}
  137. }
  138. # /dcc notice
  139. # Snak adaptation 1.4. Now only sends to the current channel - not all your channels
  140. # And don't make it reverse video.
  141. # Change wording to match the ircle fserv more closely
  142. alias dcc.ucmd.notice {
  143.     if (C)
  144.     {
  145.         if (dcc.havepacks()){
  146.             
  147.             if ($dcc.havepacks() == 1) {
  148.                 if ([$PP.SET.DCCLIMIT] != -1) {
  149.                     EVAL @ SEND_MSG = [** 1 pack ** ${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]
  150.                 }{EVAL @ SEND_MSG = [** 1 pack ** slots available]}
  151.             } { 
  152.             if ([$PP.SET.DCCLIMIT] != -1) {
  153.                     EVAL @ SEND_MSG = [** $dcc.havepacks() packs ** ${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]
  154.                 }{EVAL @ SEND_MSG = [** $dcc.havepacks() packs ** slots available]}
  155.             }
  156.             
  157.             ^pp.listmsg PRIVMSG $C
  158.             echo $SEND_MSG
  159.             
  160.             EVAL @ SEND_MSG = [** To request a file type "/msg $N xdcc send #n"]
  161.             ^pp.listmsg PRIVMSG $C
  162.             echo $SEND_MSG
  163.  
  164.             dcc.dolist 1 ^quote $0 $1 
  165.             dcc.dolist 1 ^echo 
  166.  
  167.  
  168.     #        ^pp.listmsg PRIVMSG $mychannels()
  169.     #        ^pp.listmsg PRIVMSG $C
  170.             ^assign -SEND_MSG
  171.         } {/echo *** You aren't offering any packs}
  172.         
  173.     } {/echo *** You aren't on any channels}
  174. }
  175. # /dcc offer
  176. # Snak adaptation 1.4. Modified to handle a list of file paths
  177. # Mac file paths can contain spaces, so input -files return a list that is separated with tabs
  178. # in another way. Use "listitem" to split it instead of "word"
  179. alias dcc.ucmd.offer {
  180.     ^input -files "Choose file(s) to offer: " if (1) {
  181.         if ([$0])
  182.         {
  183.             @ IDX = 0
  184.             while (listitem($IDX $*))
  185.             {
  186.                 if (fileexists($listitem($IDX $*))) {@ DCCFILS = DCCFILS##[$listitem($IDX $*) ]}
  187.                 {/echo *** File $listitem($IDX $*) does not exist or you have no permission to access}
  188.                 @ IDX = IDX + 1
  189.             }
  190.             if (DCCFILS)
  191.             {
  192.                 ^input "Enter a description for this pack: " if (1) {
  193.                     if ([$0])
  194.                     {
  195.                         @ IDX = 1
  196.                         while (DCCPACKS.FILES[$IDX]) {@ IDX = IDX + 1}
  197.                         @ DCCPACKS.FILES[$IDX] = DCCFILS
  198.                         @ DCCPACKS.DESC[$IDX] = [$*]
  199.                         @ DCCPACKS.STATS[$IDX] = [$W 0]
  200.                         echo *** Pack #$IDX added with files: ${DCCFILS}
  201.                         ^assign -IDX
  202.                         ^assign -DCCFILS
  203.                     }
  204.                     {
  205.                         ^assign -IDX
  206.                         ^assign -DCCFILS
  207.                         echo *** You must enter a description
  208.                     }
  209.                 }
  210.             }
  211.             {
  212.                 ^assign -IDX
  213.                 echo *** No files in pack!
  214.             }
  215.         } {/echo *** No files in pack!}
  216.     }
  217. }
  218. # /dcc doffer
  219. # snak adaptation 1.5 use listitem
  220. alias dcc.ucmd.doffer {
  221.     ^input "Enter pack number(s) to remove: " if (1) {
  222.         if ([$0])
  223.         {
  224.             @ AA = 0
  225.             while (word($AA $*))
  226.             {
  227.                 if (DCCPACKS.FILES[$listitem($AA $*)])
  228.                 {
  229.                     ^assign -DCCPACKS.FILES[$listitem($AA $*)]
  230.                     ^assign -DCCPACKS.DESC[$word($AA $*)]
  231.                     ^assign -DCCPACKS.STATS[$word($AA $*)]
  232.                     @ CTR = word($AA $*) + 1
  233.                     while (DCCPACKS.FILES[$CTR])
  234.                     {
  235.                         @ DCCPACKS.FILES[${CTR-1}] = DCCPACKS.FILES[$CTR]
  236.                         @ DCCPACKS.DESC[${CTR-1}] = DCCPACKS.DESC[$CTR]
  237.                         @ DCCPACKS.STATS[${CTR-1}] = DCCPACKS.STATS[$CTR]
  238.                         if (!(DCCPACKS.FILES[${CTR+1}]))
  239.                         {
  240.                             ^assign -DCCPACKS.FILES[$CTR]
  241.                             ^assign -DCCPACKS.DESC[$CTR]
  242.                             ^assign -DCCPACKS.STATS[$CTR]
  243.                         }
  244.                         @ CTR = CTR + 1
  245.                     }
  246.                     echo *** Pack #$word($AA $*) removed
  247.                 } {/echo *** There is no pack #$word($AA $*)}
  248.                 @ AA = AA + 1
  249.             }
  250.             ^assign -CTR
  251.         }
  252.     }
  253. }
  254. # /dcc list
  255. alias dcc.ucmd.list {
  256.     if (dcc.havepacks())
  257.     {
  258.         if (PP.SET.DCCLIMIT > 0) {/echo *** Files offered: [${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]}
  259.         {/echo *** Files offered:}
  260.         dcc.dolist 1 echo ***
  261.     } {/echo *** You have no files offered}
  262. }
  263. # /dcc save
  264. # Snak adaptation 1.4. Save package file in "home" directory, which for Snak is the scripts directory
  265. # Snak adaptation 1.5 use listitem
  266. #                      don't test to see if it is a full path, and don't prepend the stats
  267. #                       the addpack function can't deal with it - it is a bug in purepak 
  268. alias dcc.ucmd.save {
  269.     if ([$0])
  270.     {
  271.         @ LF = [${HOME}/$0]
  272.         exec -name rm $PP.SET.RMCMD ${HOME}/$0
  273.         wait -CMD %rm if (1) {
  274.             if (PP.EPIC)
  275.             {
  276.                 @ FHANDLE = open($LF w)
  277.                 if (FHANDLE > 0) {/EVAL ^assign WC /write $FHANDLE}
  278.                 {/echo *** Could not open $LF}
  279.             }
  280.             {
  281.                 ^window new
  282.                 ^window hold_mode off
  283.                 ^window name WRITEDCC
  284.                 ^window logfile $LF
  285.                 ^window log on
  286.                 @ WC = [/xecho -WINDOW WRITEDCC]
  287.             }
  288.             $WC # PurePak DCC module offer file, written $stime($time())
  289.             foreach DCCPACKS.FILES AA {
  290.                 @ CT = 0
  291.                 @ DFILES = []
  292.                 while (listitem($CT $DCCPACKS.FILES[$AA]))
  293.                 {
  294. #                    if (match(/* $listitem($CT $DCCPACKS.FILES[$AA]))) 
  295. #                    {
  296.                     @ DFILES = DFILES##[$listitem($CT $DCCPACKS.FILES[$AA]) ]
  297. #                    }
  298. #                    {
  299. #                    @ DFILES = DFILES##[$word(0 $DCCPACKS.STATS[$AA])/$listitem($CT $DCCPACKS.FILES[$AA]) ]
  300. #                    }
  301.                     
  302.                     @ CT = CT + 1
  303.                 }
  304.                 $WC ^dcc.addpack $encode($DFILES) $encode($DCCPACKS.DESC[$AA])
  305.             }
  306.             ^assign -CT
  307.             ^assign -DFILES
  308.             if (DCC.NOTE) {$WC ^dcc.ucmd.note $DCC.NOTE}
  309.             if (PP.EPIC)
  310.             {
  311.                 comment $close($FHANDLE)
  312.                 ^assign -FHANDLE
  313.             }
  314.             {
  315.                 ^window log off
  316.                 ^window kill
  317.             }
  318.             echo *** Current pack data written to $LF
  319.             ^assign -LF
  320.             ^assign -WC
  321.         }
  322.     } {/dcc.ucmd.save purepak.dcc}
  323. }
  324. # /dcc load
  325. alias dcc.ucmd.load {^if ([$0]) {//load $0} {//load purepak.dcc}}
  326. # /dcc plist
  327. alias dcc.ucmd.plist {
  328.     if (dcc.havepacks())
  329.     {
  330.         say Files offered: Type /msg $N xdcc send #N to get pack #N
  331.         if (PP.SET.DCCLIMIT > 0) {/say [${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]}
  332.         dcc.dolist 0 say
  333.     } {/echo *** You have no files offered}
  334. }
  335. # /dcc dldir
  336. alias dcc.ucmd.dldir {
  337.     if ([$0])
  338.     {
  339.         @ PP.SET.DCCDLDIR = [$0]
  340.         echo *** DCC download directory is now $0
  341.     } {/echo *** DCC download directory is now ${PP.SET.DCCDLDIR}}
  342. }
  343. # /dcc limit
  344. alias dcc.ucmd.limit {
  345.     if ([$0])
  346.     {
  347.         if (([$0] == [NONE])||([$0] == [OFF])) {@ PP.SET.DCCLIMIT = [-1]}
  348.         {
  349.             if (!isalpha($0)) {@ PP.SET.DCCLIMIT = [$0]}
  350.             {/echo *** Must be a numerical value}
  351.         }
  352.     }
  353.     if (PP.SET.DCCLIMIT == [-1]) {/echo *** DCC autosend file limit is now UNLIMITED}
  354.     {/echo *** DCC autosend file limit is now ${PP.SET.DCCLIMIT}}
  355. }
  356. # /dcc limit
  357. alias dcc.ucmd.timeout {
  358.     if ([$0])
  359.     {
  360.         if (([$0] == [NONE])||([$0] == [OFF])) {@ PP.SET.DCCTIMEOUT = [-1]}
  361.         {
  362.             if (!isalpha($0)) {@ PP.SET.DCCTIMEOUT = [$0]}
  363.             {/echo *** Must be a numerical value}
  364.         }
  365.     }
  366.     if (PP.SET.DCCTIMEOUT == [-1]) {/echo *** DCC autosend timeout is now UNLIMITED}
  367.     {/echo *** DCC autosend timeout is now ${PP.SET.DCCTIMEOUT}}
  368. }
  369. # /dcc autoget
  370. alias dcc.ucmd.autoget {
  371.     if (match($0 ON OFF)) {@ PP.SET.DCCAUTOGET = toupper($0)}
  372.     echo *** DCC autoget is now ${PP.SET.DCCAUTOGET}
  373. }
  374. # /dcc friends
  375. alias dcc.ucmd.friends {
  376.     if (match($0 ON OFF)) {@ PP.SET.DCCFLAUTOGET = toupper($0)}
  377.     echo *** DCC autoget from people in friends list is now ${PP.SET.DCCFLAUTOGET}
  378. }
  379. # /dcc get
  380. alias dcc.ucmd.get {
  381.     if ([$0])
  382.     {
  383.         if ([$1])
  384.         {
  385.             @ AA = 1
  386.             ^on ^window "% *No file offered in SEND*" {@ AA = 0}
  387.             //dcc get $0 $1
  388.             if (!AA) {/echo *** File $1 not offered by $0}
  389.         }
  390.         {
  391.             if ([$0])
  392.             {
  393.                 dcc.updatestatus
  394.                 @ FL = 0
  395.                 foreach DCC.GETS AA {
  396.                     if (toupper($decode($AA)) == toupper($0))
  397.                     {
  398.                         @ FL = 1
  399.                         EVAL foreach DCC.GETS.$AA XY {//dcc get $0 $decode($XY)}
  400.                         ^assign -XY
  401.                         echo *** Got all files offered by $0
  402.                     }
  403.                 }
  404.                 if (!FL) {/echo *** No files offered by $0}
  405.                 ^assign -FL
  406.             }
  407.             {
  408.                 dcc.updatestatus
  409.                 if (DCC.GETS)
  410.                 {
  411.                     foreach DCC.GETS AA {
  412.                         EVAL foreach DCC.GETS.$AA XY {//dcc get $decode($AA) $decode($XY)}
  413.                         ^assign -XY
  414.                     }
  415.                 } {/echo *** No files offered}
  416.             }
  417.         }
  418.     } {/echo *** /dcc get [<nick>] [<file>]}
  419. }
  420. # /dcc close
  421. alias dcc.ucmd.close {
  422.     if (match($0 RAW TALK CHAT RAW_LISTEN RAW_LIS)) {//dcc close $*}
  423.     {
  424.         @ AA = 0
  425.         if ([$0] == [SEND])
  426.         {
  427.             if ([$1])
  428.             {
  429.                 if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}
  430.                 if ([$2]) {//dcc close $*}
  431.                 {
  432.                     EVAL ^repeatcmd 30 //^dcc close send $1
  433.                     echo *** All DCC SENDs to $1 closed
  434.                 }
  435.             } {/echo *** /dcc close send <nick> [<file>]}
  436.             @ AA = 1
  437.         }
  438.         if ([$0] == [GET])
  439.         {
  440.             if ([$1])
  441.             {
  442.                 if ([$2]) {//dcc close $*}
  443.                 {
  444.                     EVAL ^repeatcmd 30 //^dcc close get $1
  445.                     echo *** All DCC GETs from $1 closed
  446.                 }
  447.             } {/echo *** /dcc close get <nick> [<file>]}
  448.             @ AA = 1
  449.         }
  450.         if (!AA) {/echo *** /dcc close <type> <nick> [<arguments>]}
  451.     }
  452. }
  453.  
  454. # ----------------------------------------------------------------------------
  455. # ON hooks and internal procedures
  456. # ----------------------------------------------------------------------------
  457. # Snak adaptation 1.6. Snak does its own DCC Autoaccept
  458. #         Furthermore, this code does not always work because it assumes that there are no spaces 
  459. #       in the filename. If there is then $6 will be incorrect and the script fails.
  460.  
  461. # on ^ctcp "% % DCC SEND % % % *" {
  462. #    
  463. #    echo *** DCC SEND 1 $1 2 $2 3 $3 4 $4 5 $5 6 $6
  464. #    if (([$6] > 1024)&&([$6] < 65535))
  465. #    {
  466. #        if (!ischannel($1))
  467. #        {
  468. #            if ((!!(PP.SET.DCCDLDIR))&&(PP.SET.DCCDLDIR != [.])) {//dcc rename $0 $4 ${PP.SET.DCCDLDIR}/$4}
  469. #            if (PP.SET.DCCAUTOGET == [ON])
  470. #            {
  471. #                echo *** Autogetting DCC SEND $4 from $0
  472. #                ^timer 2 //dcc get $0 $4
  473. #            }
  474. #            {
  475. #                if (PP.SET.DCCFLAUTOGET == [ON])
  476. #                {
  477. #                    foreach PP.FRIENDS AA {@ FNDS = FNDS##[ $PP.FRIENDS[$AA]]}
  478. #                    if (rmatch($0!$USERHOST() $FNDS))
  479. #                    {
  480. #                        echo *** Autogetting DCC SEND $4 from $0\; $0 is on your friends list
  481. #                        //dcc get $0 $4
  482. #                    }
  483. #                    ^assign -FNDS
  484. #                }
  485. #            }
  486. #        } {/echo *** Strange: $0 sent a DCC SEND request adressed to channel $1}
  487. #    }
  488. #    {
  489. #        ^timer 1 /echo *** DCC SEND request from $0 using priviledged port detected\; ignored (bomb?)
  490. #        //dcc close get $0 $4
  491. #    }
  492. # }
  493.  
  494. # on ^ctcp "% % DCC CHAT % % *" {
  495. #    if (([$6] < 1024)||([$6] > 65535))
  496. #    {
  497. #        ^timer 1 /echo *** DCC CHAT request from $0 using priviledged port detected\; ignored (bomb?)
  498. #        //dcc close chat $0
  499. #        //dcc close chat $0
  500. #    }
  501. #    {
  502. #        if (PP.SET.DCCAUTOCHAT == [ON])
  503. #        {
  504. #            ^timer 1 /echo *** Autogetting DCC CHAT request from $0
  505. #            //dcc chat $0
  506. #        }
  507. #        {
  508. #            if (PP.SET.DCCFLAUTOGET == [ON])
  509. #            {
  510. #                foreach PP.FRIENDS AA {@ FNDS = FNDS##[ $PP.FRIENDS[$AA]]}
  511. #                if (rmatch($0!$USERHOST() $FNDS))
  512. #                {
  513. #                    ^timer 1 /echo *** Autogetting DCC CHAT request from $0\; $0 is on your friends list
  514. #                    //dcc chat $0
  515. #                }
  516. #                ^assign -FNDS
  517. #            }
  518. #        }
  519. #    }
  520. # }
  521.  
  522. # We use a raw_irc for on msg to prevent a beep if BEEP_ON_MSG is set
  523. on ^raw_irc "% PRIVMSG % :XDCC *" {
  524.     if (!ischannel($2))
  525.     {
  526.         if (PP.SET.DCCSERVER == [ON]) {/dcc.msg $nickonly($0) $N $mid(${index(! $0)+1} 1000 $0) $4-}
  527.     }
  528.     {
  529.         if ([$2] == C) {/xecho -LEVEL PUBLIC <$nickonly($0)> $strip(: $3) $4-}
  530.         {/xecho -LEVEL PUBLIC <$nickonly($0):$2> $strip(: $3) $4-}
  531.     }
  532. }
  533. on ^ctcp "% % XDCC *" {^if (PP.SET.DCCSERVER == [ON]) {/dcc.msg $0 $1 $USERHOST() $3-}}
  534. alias dcc.msg {
  535.     if (right(10 $2) != LASTDCCER)
  536.     {
  537.         if (ischannel($1))
  538.         {
  539.             if (match($3 SEND LIST HELP VERSION LSPACK))
  540.             {
  541.                 if ([$3] == [LIST])
  542.                 {
  543.                     if (PP.SET.DCCPUBLIST == [ON])
  544.                     {
  545.                         if (dcc.havepacks()) {/dcc.msg $0 $N $2-}
  546.                     } {/echo *** $0 request for DCC LIST to everyone in $1 ignored}
  547.                 }
  548.                 {
  549.                     echo *** $0 request for DCC $toupper($3) to everyone in $1 ignored\; only LIST is allowed globally
  550.                     //^notice $0 Only DCC LISTs are allowed globally
  551.                 }
  552.             }
  553.             {
  554.                 echo *** Invalid DCC server command from $0 to $1
  555.                 //^notice $0 Unknown DCC server command\; type /msg $N XDCC HELP
  556.             }
  557.         }
  558.         {
  559.             if (match($3 SEND LIST HELP VERSION LSPACK)) {/dcc.mcmd.$3 $0 $2 $4-}
  560.             {
  561.                 echo *** Invalid DCC server command from $0
  562.                 //^notice $0 Unknown DCC server command\; type /msg $N XDCC HELP
  563.             }
  564.         }
  565.     }
  566.     if (!LASTDCCER) {^timer 3 ^assign -LASTDCCER}
  567.     @ LASTDCCER = right(10 $2)
  568. }
  569.  
  570. # Updates DCC status variables by capturing /dcc's output
  571. # Doesn't work on EPIC clients :P
  572. alias dcc.updatestatus {
  573.     ^on ^window "% Type*Nick*Status*Start*time*Sent*Read*Arguments*" {}
  574.     ^on ^window "% SEND *" {
  575.         if ([$3] == [Waiting]) {@ DCC.SENDS[$encode($2)][$encode($6)] = [W $4 $5]} {@ DCC.SENDS[$encode($2)][$encode($10)] = [A $8 $9]}
  576.         @ DCC.SENDS = 1
  577.     }
  578.     ^on ^window "% GET *" {
  579.         if ([$3] == [Offered]) {@ DCC.GETS[$encode($2)][$encode($6)] = [W $4 $5]} {@ DCC.GETS[$encode($2)][$encode($10)] = [A $8 $9]}
  580.         @ DCC.GETS = 1
  581.     }
  582.     ^on ^window "% RAW *" {}
  583.     ^on ^window "% CHAT *" {
  584.         if ([$3] == [Waiting]) {@ DCC.CHATS[$encode($2)] = [W $4 $5]}
  585.         {
  586.             if ([$3] == [Offered]) {@ DCC.CHATS[$encode($2)] = [O $4 $5]} {@ DCC.CHATS[$encode($2)] = [A $8 $9]}
  587.         }
  588.         @ DCC.CHATS = 1
  589.     }
  590.     ^on ^window "% RAW_LIS *raw_listen*" {}
  591.     ^on ^window "% TALK *" {}
  592.     foreach DCC.SENDS AA {/EVAL ^foreach DCC.SENDS.$AA BB {^assign -DCC.SENDS[$AA][$BB]}}
  593.     foreach DCC.GETS AA {/EVAL ^foreach DCC.GETS.$AA BB {^assign -DCC.GETS[$AA][$BB]}}
  594.     foreach DCC.CHATS AA {^assign -DCC.CHATS[$AA]}
  595.     ^assign -DCC.SENDS
  596.     ^assign -DCC.GETS
  597.     ^assign -DCC.CHATS
  598.     ^assign -BB
  599.     //dcc
  600.     ^on window - "% TALK *"
  601.     ^on window - "% CHAT *"
  602.     ^on window - "% RAW *"
  603.     ^on window - "% GET *"
  604.     ^on window - "% RAW_LIS *raw_listen*"
  605.     ^on window - "% Type*Nick*Status*Start*time*Sent*Read*Arguments*"
  606.     ^on window - "% SEND *"
  607. }
  608.  
  609. # Executed when a saved pack file loads
  610. # snak adaptation 1.5 use listitem
  611. alias dcc.addpack {
  612.     @ FILZ = decode($0)
  613.         
  614.     @ AA = 0
  615.     while (listitem($AA $FILZ))
  616.     {
  617.     
  618.     echo there
  619.         if (!fileexists($listitem($AA $FILZ)))
  620.         {
  621.             ^delword $listitem($AA $FILZ) $FILZ
  622.             echo *** LOAD: file $listitem($AA $FILZ) does not exist, removed from pack
  623.             @ FILZ = NLIST
  624.             ^assign -NLIST
  625.         }
  626.         @ AA = AA + 1
  627.     }
  628.     
  629.     if ([$#FILZ] > 0)
  630.     {
  631.         @ IDX = 1
  632.         while (DCCPACKS.FILES[$IDX]) {@ IDX = IDX + 1}
  633.         @ DCCPACKS.FILES[$IDX] = FILZ
  634.         @ DCCPACKS.DESC[$IDX] = decode($1)
  635.         @ DCCPACKS.STATS[$IDX] = [$W 0]
  636.         echo *** Pack #$IDX loaded with files: $FILZ
  637.         echo ***   - Description: $decode($1)
  638.         ^assign -IDX
  639.     } {/echo *** Pack not restored: no files}
  640.     ^assign -FILZ
  641. }
  642.  
  643. # Executed whenever the user changes nicks with /nick
  644. alias dcc.onnick {
  645.     if ([$0])
  646.     {
  647.         @ DCC.MYNICK = [$0]
  648.         EVAL ^on raw_irc - "${N}!% PRIVMSG $N :DCC SEND **"
  649.         EVAL ^on ^raw_irc "$0!% PRIVMSG $0 :DCC SEND **" {
  650.             @ DCC.SINT.FNAME = [$5]
  651.             @ DCC.SINT.FSIZE = strip( $8)
  652.             //^dcc close send $N
  653.             //^dcc close get $N
  654.             $DCC.ONREPCMD
  655.         }
  656.     }
  657. }
  658. EVAL ^on ^raw_irc "${N}!% PRIVMSG $N :DCC SEND **" {
  659.     @ DCC.SINT.FNAME = [$5]
  660.     @ DCC.SINT.FSIZE = strip( $8)
  661.     //^dcc close send $N
  662.     //^dcc close get $N
  663.     $DCC.ONREPCMD
  664. }
  665. @ DCC.ONREPCMD = [/dcc.norepcmd]
  666. alias dcc.norepcmd {
  667.     @ DCC.FSIZES[$encode($tolower($DCC.SINT.FNAME))] = DCC.SINT.FSIZE
  668.     ^assign -DCC.SINT.FNAME
  669.     ^assign -DCC.SINT.FSIZE
  670. }
  671.  
  672. # Checks to see if a file exists by trapping window output from a DCC SEND
  673. # to yourself.
  674. # Snak adaptation 1.4. Removed alias and made a built in function
  675.  
  676. #alias fileexists {
  677. #    @ EXISTS = 1
  678. #    ^on ^window "% *Cannot access*" {@ EXISTS = 0}
  679. #    ^on ^window * {}
  680. #    //dcc send $N $0
  681. #    ^on window - "% *Cannot access*"
  682. #    ^on window - *
  683. #    @ FUNCTION_RETURN = EXISTS
  684. #    ^assign -EXISTS
  685. #}
  686.  
  687. # args=<files>, returns sum of all file sizes, or 0 if a file's size isn't
  688. # saved in the buffer
  689. alias dcc.getpacksize {
  690.     @ PSIZE = 0
  691.     @ CT = 0
  692.     while ((!!word($CT $*))&&(PSIZE != [-1]))
  693.     {
  694.         @ FN = dcc.nameonly($word($CT $*))
  695.         if (DCC.FSIZES[$encode($tolower($FN))])
  696.         {
  697.             @ PSIZE = PSIZE + DCC.FSIZES[$encode($tolower($FN))]
  698.         } {@ PSIZE = [-1]}
  699.         @ CT = CT + 1
  700.     }
  701.     ^assign -CT
  702.     ^assign -FN
  703.     if (PSIZE == [-1]) {@ FUNCTION_RETURN = 0}
  704.     {@ FUNCTION_RETURN = PSIZE}
  705.     ^assign -PSIZE
  706. }
  707.  
  708. # /dcc.dolist <show filenames too?> <command to do list>
  709. alias dcc.dolist {
  710.     @ MAXV = 0
  711.     foreach DCCPACKS.FILES AA {^if (AA > MAXV) {@ MAXV = AA}}
  712.     @ AA = 0
  713.     while (AA <= MAXV)
  714.     {
  715.         if (DCCPACKS.FILES[$AA]) 
  716.         {
  717.             $1- #${AA} - $DCCPACKS.DESC[$AA]
  718.             @ FILS = DCCPACKS.FILES[$AA]
  719.             EVAL $1-    + [$#FILS file(s)] [$dcc.getpacksize($FILS) bytes] [downloaded $word(1 $DCCPACKS.STATS[$AA]) times]
  720.             if ([$0]) {$1- #${AA} - Files: $FILS}
  721.         }
  722.         @ AA = AA + 1
  723.     }
  724.     ^assign -FILS
  725.     ^assign -MAXV
  726.     if (DCC.NOTE) {$1- * Note: $DCC.NOTE}
  727. }
  728.  
  729. # Snak adaptation 1.4. returns number of packages offered
  730. alias dcc.havepacks {
  731.     @ FUNCTION_RETURN = 0
  732.     foreach DCCPACKS.FILES BsB {}
  733.     @ FUNCTION_RETURN = [$BsB]
  734.     ^assign -BsB
  735. }
  736.  
  737. # Queues a send for the timeout timer
  738. alias dcc.queuetimeout {@ DCC.TIMEOUTS[$encode($0)][$rand(99999)] = [$1 $2 $3]}
  739.  
  740. # Checks for DCC's that have timed out and runs queued DCC's
  741. on #^timer 22 * {
  742.     if (PP.SET.DCCTIMEOUT != [-1])
  743.     {
  744.         foreach DCC.TIMEOUTS AA {
  745.             EVAL ^foreach DCC.TIMEOUTS.$AA BB {
  746.                 if ([${time() - word(1 $DCC.TIMEOUTS[$AA][$BB])}] >= PP.SET.DCCTIMEOUT)
  747.                 {
  748.                     //^dcc close send $decode($AA) $word(2 $DCC.TIMEOUTS[$AA][$BB])
  749.                     //^dcc close send $decode($AA) ${W}/$word(0 $DCC.TIMEOUTS[$AA][$BB])
  750.                     if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}
  751.                     echo *** DCC SEND $word(2 $DCC.TIMEOUTS[$AA][$BB]) to $decode($AA) timed out
  752.                     //^notice $decode($AA) DCC SEND $word(2 $DCC.TIMEOUTS[$AA][$BB]) timed out
  753.                     ^assign -DCC.TIMEOUTS[$AA][$BB]
  754.                 }
  755.             }
  756.         }
  757.     }
  758.     if (PP.SET.DCCLIMIT != [-1])
  759.     {
  760.         while (dcc.gotqueue())
  761.         {
  762.             @ BB = 0
  763.             @ OLDESTQUEUE = 0
  764.             foreach DCC.SENDQUEUE AA {
  765.                 if ([${time() - AA}] > BB)
  766.                 {
  767.                     @ BB = time() - AA
  768.                     @ OLDESTQUEUE = AA
  769.                 }
  770.             }
  771.             echo *** Sending queued pack #$strip(# $word(2 $DCC.SENDQUEUE[$OLDESTQUEUE])) to $word(0 $DCC.SENDQUEUE[$OLDESTQUEUE])
  772.             ^alias echo {}
  773.             ^dcc.mcmd.send $DCC.SENDQUEUE[$OLDESTQUEUE]
  774.             ^alias -echo
  775.             ^assign -DCC.SENDQUEUE[$OLDESTQUEUE]
  776.         }
  777.         ^assign -OLDESTQUEUE
  778.     }
  779.     {
  780.         foreach DCC.SENDQUEUE AA {
  781.             echo *** Sending queued pack #$strip(# $word(2 $DCC.SENDQUEUE[$AA])) to $word(0 $DCC.SENDQUEUE[$AA])
  782.             ^alias echo {}
  783.             ^dcc.mcmd.send $DCC.SENDQUEUE[$AA]
  784.             ^alias -echo
  785.             ^assign -DCC.SENDQUEUE[$AA]
  786.         }
  787.     }
  788.     ^assign -BB
  789. }
  790.  
  791. # Returns true if files are queued and there are slots available
  792. alias dcc.gotqueue {
  793.     @ FUNCTION_RETURN = 0
  794.     foreach DCC.SENDQUEUE AB {^if (DCC.NSENDING < PP.SET.DCCLIMIT) {@ FUNCTION_RETURN = 1}}
  795.     ^assign -AB
  796. }
  797.  
  798. # Removes timeouts when sends are initiated
  799. on -window "% % DCC SEND connection to*established*" {
  800.     if (match(*[* $6)) {@ NIQ = left($index([ $6) $6)} {@ NIQ = [$6]}
  801.     foreach DCC.TIMEOUTS AA {^if (decode($AA) == NIQ) {^EVAL ^foreach DCC.TIMEOUTS.$AA BB {^assign -DCC.TIMEOUTS[$AA][$BB]}}}
  802.     ^assign -BB
  803.     ^assign -NIQ
  804. }
  805.  
  806. # Removes path from a filename
  807. alias dcc.nameonly {^if (match(*/* $0)) {@ FUNCTION_RETURN = mid(${rindex(/ $0)+1} 1000 $0)} {@ FUNCTION_RETURN = [$0]}}
  808.  
  809. # ----------------------------------------------------------------------------
  810. # User /msg command functions
  811. # ----------------------------------------------------------------------------
  812.  
  813. alias dcc.mcmd.version {
  814.     if (index(Y $PP.SET) == [-1])
  815.     {
  816.         //^notice $0 PurePak version $PPVERS DCC module
  817.         echo *** $0 [$strip( $1)] requested your version
  818.     }
  819. }
  820. alias dcc.mcmd.help {
  821.     //^notice $0 Available DCC server commands:
  822.     //^notice $0 HELP, LIST, SEND <#pack>, LSPACK <#pack>, VERSION
  823.     echo *** $0 [$strip( $1)] requested DCC server help
  824. }
  825. alias dcc.mcmd.list {
  826.     if (dcc.havepacks())
  827.     {
  828.         //^notice $0 Files available: Type /msg $N XDCC SEND #N to get pack #N
  829.         if (PP.SET.DCCLIMIT > 0) {//^notice $0 [${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]}
  830.         EVAL ^dcc.dolist 0 //^notice $0
  831.         echo *** $0 [$strip( $1)] requested a list of files offered
  832.     } {//^notice $0 No files offered}
  833. }
  834. # snak adaptation 1.5 use listitem
  835. alias dcc.mcmd.lspack {
  836.     if (DCCPACKS.FILES[$strip(# $2)])
  837.     {
  838.         //^notice $0 Files in pack #$strip(# $2)
  839.         @ AA = 0
  840.         while (listitem($AA $DCCPACKS.FILES[$strip(# $2)]))
  841.         {
  842.             //^notice $0   $dcc.nameonly($listitem($AA $DCCPACKS.FILES[$strip(# $2)])) [$dcc.getpacksize($listitem($AA $DCCPACKS.FILES[$strip(# $2)])) bytes]
  843.             @ AA = AA + 1
  844.         }
  845.         echo *** $0 [$strip( $1)] requested a list of files in pack #$strip(# $2)
  846.     } {//^notice $0 There is no pack #$strip(# $2)}
  847. }
  848. @ DCC.NSENDING = 0
  849.  
  850. # snak adaptation 1.5 use listitem and don't check for /
  851.  
  852. alias dcc.mcmd.send {
  853.  
  854.     if (DCCPACKS.FILES[$strip(# $2)])
  855.     {
  856.         if ((DCC.NSENDING >= PP.SET.DCCLIMIT)&&(PP.SET.DCCLIMIT != [-1]))
  857.         {
  858.             if (PP.SET.DCCQUEUEING == [ON])
  859.             {
  860.                 @ ALREADY = 0
  861.                 foreach DCC.SENDQUEUE AA {
  862.                     if ((word(0 $DCC.SENDQUEUE[$AA]) == [$0])&&(word(2 $DCC.SENDQUEUE[$AA]) == [$2]))
  863.                     {
  864.                         //^notice $0 You already have a request for pack #$strip(# $2) queued
  865.                         @ ALREADY = 1
  866.                     }
  867.                 }
  868.                 if (!ALREADY)
  869.                 {
  870.                     @ DCC.SENDQUEUE[$time()] = [$*]
  871.                     echo *** DCC SEND request for pack #$strip(# $2) to $0 queued: no more slots available
  872.                     //^notice $0 No more DCC slots available: your request has been queued
  873.                 }
  874.                 ^assign -ALREADY
  875.             }
  876.             {
  877.                 //^notice $0 No more DCC slots available
  878.                 echo *** DCC SEND request for pack #$strip(# $2) to $0 denied: no more slots available
  879.             }
  880.         }
  881.         {
  882.             @ PACKNUM = strip(# $2)
  883.             //^notice $0 Sending you pack #$PACKNUM \(you will need $dcc.getpacksize($DCCPACKS.FILES[$PACKNUM]) bytes\)
  884.             //^notice $0 Type /dcc get $N <file> for each request received
  885.             @ CTR = 0
  886.             @ AA = word(1 $DCCPACKS.STATS[$PACKNUM])
  887.             @ DCCPACKS.STATS[$PACKNUM] = [$word(0 $DCCPACKS.STATS[$PACKNUM]) ${AA+1}]
  888.             while (listitem($CTR $DCCPACKS.FILES[$PACKNUM]))
  889.             {
  890.                 @ AA = listitem($CTR $DCCPACKS.FILES[$PACKNUM])
  891. #                {
  892. #                    //^dcc close send $0 $word(0 $DCCPACKS.STATS[$PACKNUM])/$AA
  893. #                    //^dcc send $0 $word(0 $DCCPACKS.STATS[$PACKNUM])/$AA
  894. #                    @ SF = [$word(0 $DCCPACKS.STATS[$PACKNUM])/$AA]
  895. #                }
  896. #                {
  897.                     //^dcc close send $0 $AA
  898.                     //^dcc send $0 $AA
  899.                     @ SF = AA
  900. #                }
  901.                 if (PP.SET.DCCTIMEOUT > 0) {^dcc.queuetimeout $0 $dcc.nameonly($AA) $time() $SF}
  902.                 @ DCC.NSENDING = DCC.NSENDING + 1
  903.                 if ((PP.SET.DCCLIMIT != [-1])&&(DCC.NSENDING > PP.SET.DCCLIMIT)) {@ DCC.NSENDING = PP.SET.DCCLIMIT}
  904.                 @ CTR = CTR + 1
  905.             }
  906.             ^assign -SF
  907.             ^assign -CTR
  908.             echo *** DCC pack #$PACKNUM sent to $0 [$strip( $1)]
  909.             ^assign -PACKNUM
  910.         }
  911.     } {//^notice $0 There is no pack #$strip(# $2)}
  912. }
  913. on -window "% % DCC SEND:% *completed*" {^if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}}
  914. on -window "% % DCC SEND:% *lost*" {^if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}}
  915.  
  916. # ----------------------------------------------------------------------------
  917.  
  918. EVAL ^if (!PP.SET.NOSTARTUP) {/echo -- PurePak DCC server module loaded}
  919.